package aaa

import (
	"sync"
	"github.com/gorilla/websocket"
)

type Ws链接_标识 struct {
	链接表列 map[string]map[string][]*websocket.Conn
	锁列表 map[string]map[string][]*sync.RWMutex
	读写许可 *sync.RWMutex
}

func (类 *Ws链接_标识) C初始化() {
	类.链接表列 = make(map[string]map[string][]*websocket.Conn)
	类.锁列表 =make(map[string]map[string][]*sync.RWMutex)
	类.读写许可 = &sync.RWMutex{}
}

func (类 *Ws链接_标识) Z增加链接(方法名 string, 标识 string, 链接 *websocket.Conn) {
	类.读写许可.Lock()
    defer 类.读写许可.Unlock()

    // 初始化方法名和标识的嵌套 map
    if _, ok := 类.链接表列[方法名]; !ok {
        类.链接表列[方法名] = make(map[string][]*websocket.Conn)
    }
    if _, ok := 类.锁列表[方法名]; !ok {
        类.锁列表[方法名] = make(map[string][]*sync.RWMutex)
    }
    if _, ok := 类.链接表列[方法名][标识]; !ok {
        类.链接表列[方法名][标识] = []*websocket.Conn{}
        类.锁列表[方法名][标识] = []*sync.RWMutex{}
    }

    // 检查链接是否已存在
    for _, v := range 类.链接表列[方法名][标识] {
        if v == 链接 {
            return
        }
    }

    // 添加链接和锁
    类.链接表列[方法名][标识] = append(类.链接表列[方法名][标识], 链接)
    类.锁列表[方法名][标识] = append(类.锁列表[方法名][标识], &sync.RWMutex{})
	
	

}

func (类 *Ws链接_标识) S删链接(方法名 string, 标识 string, 链接 *websocket.Conn) {
	类.读写许可.Lock()
	defer 类.读写许可.Unlock()
	if 标识列表, ok := 类.链接表列[方法名][标识]; ok {
		for i, v := range 标识列表 {

			if v == 链接 {
                // 删除链接
                类.链接表列[方法名][标识] = append(标识列表[:i], 标识列表[i+1:]...)
				锁 := 类.锁列表[方法名][标识][i]
				锁.Lock()
				锁.Unlock()
                // 删除对应的锁
                类.锁列表[方法名][标识] = append(类.锁列表[方法名][标识][:i], 类.锁列表[方法名][标识][i+1:]...)
                break
			}
		}
	}

}

func (类 *Ws链接_标识) T推送消息_文本(方法名 string, 消息 string, 标识 string) {
	类.读写许可.RLock()
	defer 类.读写许可.RUnlock()
	if 标识列表, ok := 类.链接表列[方法名][标识]; ok {
		for i, v := range 标识列表 {
			锁:=类.锁列表[方法名][标识][i]
			go 推送消息(v,锁,消息)

		}

	}

}

func (类 *Ws链接_标识) T推送消息_文本_多标识(方法名 string, 消息 string, 标识组 ...string) {
	类.读写许可.RLock()
	defer 类.读写许可.RUnlock()
	for _, 标识 := range 标识组 {
		if 标识列表, ok := 类.链接表列[方法名][标识]; ok {
			for i, v := range 标识列表 {
				锁:=类.锁列表[方法名][标识][i]
				go 推送消息(v,锁,消息)
				//go v.WriteMessage(websocket.TextMessage, []byte(消息))

			}

		}

	}

}

func (类 *Ws链接_标识) T推送消息_方法推文本(方法名 string, 消息方法 func() string, 标识 string) {
	类.读写许可.RLock()
	defer 类.读写许可.RUnlock()
	发送消息 := 消息方法()
	if 标识列表, ok := 类.链接表列[方法名][标识]; ok {
		for i, v := range 标识列表 {
			锁:=类.锁列表[方法名][标识][i]
			go 推送消息(v,锁,发送消息)
			//go v.WriteMessage(websocket.TextMessage, []byte(发送消息))

		}

	}

}

func (类 *Ws链接_标识) T推送消息_方法推文本_多标识(方法名 string, 消息方法 func()string, 标识组 ...string) {
	类.读写许可.RLock()
	defer 类.读写许可.RUnlock()
	发送消息 := 消息方法()
	for _, 标识 := range 标识组 {
		if 标识列表, ok := 类.链接表列[方法名][标识]; ok {
			for i, v := range 标识列表 {
				锁:=类.锁列表[方法名][标识][i]
				go 推送消息(v,锁,发送消息)

				//go v.WriteMessage(websocket.TextMessage, []byte(发送消息))

			}

		}

	}

}

func 推送消息(链接 *websocket.Conn,锁 *sync.RWMutex,发送消息 string){
	if 锁 == nil {
		return
	}
	锁.Lock()
	链接.WriteMessage(websocket.TextMessage, []byte(发送消息))
	锁.Unlock()
}
